package com.eianiao.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.eianiao.bean.Category;
import com.eianiao.bean.Dish;
import com.eianiao.bean.Setmeal;
import com.eianiao.bean.SetmealDish;
import com.eianiao.common.PageParam;
import com.eianiao.dao.DishDao;
import com.eianiao.dao.SetmealDao;
import com.eianiao.dao.SetmealDishDao;
import com.eianiao.dto.SetmealDto;
import com.eianiao.exception.CustomException;
import com.eianiao.service.CategoryService;
import com.eianiao.service.SetmealDishService;
import com.eianiao.service.SetmealService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.stream.Collectors;

/**
 * @Author eianiao
 * @Date 2022 06
 * @Version 1.0
 **/
@Service
@Transactional
public class SetmealServiceImpl implements SetmealService {
    @Autowired
    private SetmealDao setmealDao;

    @Autowired
    private SetmealDishService setmealDishService;

    @Autowired
    private CategoryService categoryService;


    /**
     * 根据分类菜品的id，查询出来该分类的所有菜品
     *
     * @param categoryId
     * @return
     */
    @Override
    public List<Setmeal> findByCategoryId(long categoryId) {
        LambdaQueryWrapper<Setmeal> qw = new LambdaQueryWrapper<>();
        qw.eq(Setmeal::getCategoryId,categoryId);

        return setmealDao.selectList(qw);
    }

    /**
     * 添加套餐
     *
     * @param setmealDto
     * @return
     */
    @Override
    public int add(SetmealDto setmealDto) {
        //添加套餐
        int row = setmealDao.insert(setmealDto);
        if (row > 0){
            //添加套餐中的菜品
            List<SetmealDish> dishList = setmealDto.getSetmealDishes();
            int row2 =0;
            //得到的是一个dishList集合，要遍历
            for (SetmealDish setmealDish : dishList) {
                //添加套餐菜品时要设置菜品分类
                setmealDish.setSetmealId(setmealDto.getCategoryId());
                //添加菜品
                row2 = setmealDishService.add(setmealDish);
            }
            return row2 > 0 ? 1 : 0;
        }

        return row;
    }

    /**
     * 分页查询
     *
     * @param pageParam
     * @return
     */
    @Override
    public IPage<SetmealDto> findPage(PageParam pageParam) {
        //设置分页查询总记录数和总页数
        IPage<Setmeal> iPage= new Page<>(pageParam.getPage(), pageParam.getPageSize());

        //构造查询条件
        LambdaQueryWrapper<Setmeal> qw = new LambdaQueryWrapper<>();
        qw.like(pageParam.getName() !=null,Setmeal::getName,pageParam.getName());
        IPage<Setmeal> setmealIPage = setmealDao.selectPage(iPage, qw);
        //分类和菜品还没有展示出来
        List<SetmealDto> list = setmealIPage.getRecords().stream().map((setmeal)->{
            //1.查分类
            Category category = categoryService.findById(setmeal.getCategoryId());
            //TODO: 查询套餐的菜品

            //封装分类
            SetmealDto setmealDto = new SetmealDto();
            setmealDto.setCategoryName(category.getName());
            //TODO: 封装菜品

            //封装套餐
            BeanUtils.copyProperties(setmeal,setmealDto);
            return setmealDto;
        }).collect(Collectors.toList());
        IPage<SetmealDto> dtoIPage = new Page<>();
        dtoIPage.setRecords(list);
        dtoIPage.setTotal(setmealIPage.getTotal());
        return dtoIPage;
    }


    /**
     * 删除套餐
     *  1. 不能直接认为就是删除套餐即可，要考虑套餐属于启售状态的情况
     *      1.1 如果套餐属于启售状态，那么就不能删除套餐！
     *      1.2 如果是批量删除的情况，只要有一个属于启售状态，那么就不能删除！
     *  2.  删除套餐的时候，也要考虑去删除套餐菜品表数据。否则后面
     *      套餐已经删除了，但是套餐包含的菜品数据还在！
     *
     * @param ids
     * @return
     */
    @Override
    public int deleteById(List<Long> ids) {

        //1. 先查询看看，有没有哪个套餐属于启售状态
        // select count(*) from setmeal where status = 1 and id  in (1, ,3 ,5 )   // 1, 3, 5

        //1.1 构建条件对象
        LambdaQueryWrapper<Setmeal> qw = new LambdaQueryWrapper<>();

        //1.2 设置条件
        qw.in(Setmeal::getId , ids);
        qw.eq(Setmeal::getStatus , 1);

        //1.3 执行查询
        int total = setmealDao.selectCount(qw);

        //如果 >  0  则认为是有套餐处于启售状态！
        if(total > 0 ){
            throw  new CustomException("套餐处于启售状态，禁止删除！");
        }

        //2. 如果有就禁止删除，否则就允许去执行删除
        List<Long> categoryIdList = null;
        List<Setmeal> setmealList = setmealDao.selectBatchIds(ids);
    /*    for (Setmeal setmeal : setmealList) {
            Long categoryId = setmeal.getCategoryId();
            System.out.println(categoryId);
            System.out.println("---------------------");
            categoryIdList.add(categoryId);
            System.out.println("---------------------");

        }*/
        //2.1 删除套餐表数据
        int row1 = setmealDao.deleteBatchIds(ids);

        //2.2 删除套餐菜品表数据
        for (Setmeal setmeal : setmealList) {
            Long categoryId = setmeal.getCategoryId();
            setmealDishService.deleteBySetmealId(categoryId);
        }




        return row1;
    }


    /**
     * 更新状态
     *
     * @param status
     * @param ids
     * @return
     */
    @Override
    public int updateByStatus(int status, List<Long> ids) {
        //需要构建条件
        //查询所有需要更改状态的数据
        LambdaQueryWrapper<Setmeal> qw = new LambdaQueryWrapper<>();
        qw.in(Setmeal::getId,ids);
        List<Setmeal> setmealList = setmealDao.selectList(qw);
        //遍历集合，更改状态
        int row = 0;
        if (setmealList != null){
            for (Setmeal setmeal : setmealList) {
                setmeal.setStatus(status);
                row = setmealDao.updateById(setmeal);
            }
        }
        return row > 0 ? 1 : 0;
    }

    /**
     * 更新套餐
     *
     * @param id
     * @return
     */
    @Override
    public int update(Long id) {
        LambdaQueryWrapper<Setmeal> qw = new LambdaQueryWrapper<>();
        qw.eq(Setmeal::getId,id);
        return setmealDao.updateById(setmealDao.selectOne(qw));
    }

    /**
     * 套餐回显
     *
     * @param id
     * @return
     */
    @Override
    public SetmealDto findById(Long id) {
        //通过id查询套餐的信息和套餐中的菜品
        LambdaQueryWrapper<Setmeal> qw = new LambdaQueryWrapper<>();
        qw.eq(Setmeal::getId,id);
        Setmeal setmeal = setmealDao.selectOne(qw);
        SetmealDto setmealDto = new SetmealDto();
        //封装套餐
        BeanUtils.copyProperties(setmeal,setmealDto);
        //叫setmealDishService查询套餐中的菜品
        Long categoryId = setmealDto.getCategoryId();
        List<SetmealDish> setmealDishList = setmealDishService.findBySetmealId(categoryId);
        setmealDto.setSetmealDishes(setmealDishList);

        return setmealDto;
    }

    /**
     * 更新套餐
     *
     * @param setmealDto
     * @return
     */
    @Override
    public int update(SetmealDto setmealDto) {
        Long categoryId = setmealDto.getCategoryId();
        int row = setmealDao.updateById(setmealDto);
        if (categoryId != null){
            int i = setmealDishService.deleteBySetmealId(categoryId);
            if (i > 0){
                int add = 0;
                List<SetmealDish> setmealDishList = setmealDto.getSetmealDishes();
                for (SetmealDish setmealDish : setmealDishList) {

                    setmealDish.setSetmealId(setmealDto.getCategoryId());

                     add = setmealDishService.add(setmealDish);
                }
                return add > 0 ? 1 : 0;
            }
            return 0;
        }

        return row;
    }


    //移动端

    /**
     * 根据套餐的分类，获取该分类下的套餐
     *
     * @param categoryId
     * @param status
     * @return
     */
    @Override
    public List<Setmeal> findByCategoryId(Long categoryId, Integer status) {
        LambdaQueryWrapper<Setmeal> qw = new LambdaQueryWrapper<>();
        qw.eq(Setmeal::getCategoryId , categoryId );
        qw.eq(Setmeal::getStatus , status );

        return setmealDao.selectList(qw);
    }
}
